using UnityEngine;
using UnityEngine.UI;
using Newtonsoft.Json;
using StackExchange.Redis;
using TMPro;
using WebSocketSharp;
using System.Text;
using PimDeWitte.UnityMainThreadDispatcher;
using Newtonsoft.Json.Linq;
using System;
using System.ComponentModel.Design;
using Unity.VisualScripting;

public class IdiomGame : MonoBehaviour
{
    public TextMeshProUGUI currentIdiomText;
    public TextMeshProUGUI nextIdiomText;
    public TextMeshProUGUI idiomInfoText;
    public TextMeshProUGUI jsonNameText;

    private IConnectionMultiplexer redisConnection;
    private IDatabase redisDatabase;
    private WebSocket webSocket;

    void Start()
    {
        // 连接到 Redis 服务器
        redisConnection = ConnectionMultiplexer.Connect("192.168.2.100:6379");
        redisDatabase = redisConnection.GetDatabase();

        // 连接到 WebSocket 服务器
        webSocket = new WebSocket("ws://192.168.43.1:8083/websocket");
        webSocket.OnMessage += (sender, e) => ReceiveNextIdiomFromWebSocket(sender, e);
        webSocket.Connect();

        // 游戏开始，获取随机成语
        StartGame();
    }

    void StartGame()
    {
        // 从 Redis 中获取随机成语，这里假设使用 "idioms" 集合
        RedisValue randomIdiom = redisDatabase.SetRandomMember("idioms");
        string startIdiom = randomIdiom.HasValue ? randomIdiom.ToString() : null;

        if (!string.IsNullOrEmpty(startIdiom))
        {
            // 设置初始成语
            DisplayCurrentIdiom(startIdiom);
            PlayIdiomChain();
        }
        else
        {
            Debug.LogError("无法获取起始成语。");
        }
    }

    void PlayIdiomChain()
    {
        // 在这里实现成语接龙的逻辑，包括获取成语信息和显示在 TextMeshPro 上
        // 这里简化为手动输入下一个成语
        string nextIdiom = "下个成语";
        DisplayNextIdiom(nextIdiom);

        // 获取并显示成语信息
        IdiomInfo idiomInfo = GetIdiomInfo(nextIdiom);
        if (idiomInfo != null)
        {
            DisplayIdiomInfo(idiomInfo);
        }

        // 接收 WebSocket 消息，处理下一个成语
        ReceiveNextIdiomFromWebSocket(null, null);
    }

    void ReceiveNextIdiomFromWebSocket(object sender, MessageEventArgs e)
    {
        string message = e?.Data;

        // 解析 WebSocket 消息
        var jsonData = JsonConvert.DeserializeObject<WebSocketData>(message);

        // 获取下一个成语
        string nextIdiom = jsonData?.content;

        // 检查 Redis 中是否有对应的成语
        if (!string.IsNullOrEmpty(nextIdiom) && redisDatabase.KeyExists(nextIdiom))
        {
            // 显示并处理下一个成语
            UnityMainThreadDispatcher.Instance().Enqueue(() =>
            {
                // 检查是否符合接龙规则
                if (IsIdiomChainValid(currentIdiomText.text, nextIdiom))
                {
                    DisplayNextIdiom(nextIdiom);

                    // 获取并显示成语信息
                    IdiomInfo idiomInfo = GetIdiomInfo(nextIdiom);
                    if (idiomInfo != null)
                    {
                        DisplayIdiomInfo(idiomInfo);
                    }
                }
                else
                {
                    Debug.LogError("接龙规则不符合，成语首尾不匹配。");
                }
            });
        }
        else
        {
            Debug.LogError($"Redis 中不存在成语 {nextIdiom}。");
        }
    }

    bool IsIdiomChainValid(string currentIdiom, string nextIdiom)
    {
        // 判断首尾是否匹配，这里简单示范，你可能需要更复杂的规则
        return !string.IsNullOrEmpty(currentIdiom) && !string.IsNullOrEmpty(nextIdiom) &&
               currentIdiom[currentIdiom.Length - 1] == nextIdiom[0];
    }

    IdiomInfo GetIdiomInfo(string idiom)
    {
        string idiomInfoJson = redisDatabase.StringGet(idiom);

        if (string.IsNullOrEmpty(idiomInfoJson))
        {
            Debug.LogError($"无法获取成语 {idiom} 的信息。");
            return null;
        }
        // 添加调试打印语句
        
        try
        {
            // 使用 JObject 进行解析
            JObject jsonObject = JObject.Parse(idiomInfoJson);
            Debug.Log(idiomInfoJson);


            // 获取 Description 字段的值
            string descriptionValue = jsonObject["derivation"]?.ToString();

            // 获取其他字段的值，以及可能的异常处理...
            Debug.Log(descriptionValue);
            // 构造 IdiomInfo 对象
            IdiomInfo idiomInfo = new IdiomInfo
            {
                // 其他字段赋值...
                Description = descriptionValue
                
        };
            
            return idiomInfo;
        }
        catch (Exception e)
        {
            Debug.LogError($"解析成语信息时发生异常：{e.Message}");
            return null;
        }
    }



    [System.Serializable]
    public class DescriptionInfo
    {
        public string Description;
    }


    void DisplayCurrentIdiom(string currentIdiom)
    {
        currentIdiomText.text = "成语：" + currentIdiom;
    }

    void DisplayNextIdiom(string nextIdiom)
    {
        nextIdiomText.text = "成语：" + nextIdiom;
    }

    void DisplayIdiomInfo(IdiomInfo idiomInfo)
    {
        idiomInfoText.text = "成语简介：" + idiomInfo.Description;
        jsonNameText.text = "JSON 名字：" + idiomInfo.JsonName;
    }

    void OnDestroy()
    {
        // 在脚本销毁时关闭 Redis 连接和 WebSocket 连接
        if (redisConnection != null)
        {
            redisConnection.Close();
        }

        if (webSocket != null && webSocket.IsAlive)
        {
            webSocket.Close();
        }
    }
}

[System.Serializable]
public class IdiomInfo
{
    public string Idiom;
    public string Description;
    public string JsonName;

}

[System.Serializable]
public class WebSocketData
{
    public string nickName;
    public string content;
}
